package com.java.Map.TreeMap;

import java.util.Comparator;
import java.util.TreeMap;

/**
 * TreeMap排序
 */
public class TreeMapSort {
    static class Inner implements Comparable<Inner> {
        private int num;
        
        public Inner(int num) {
            this.num = num;
        }
        
        @Override
        public int compareTo(Inner o) {
            // this表示被添加的元素，返回负数时被添加元素放左侧，但返回负数也意味着被添加元素更大，所以是降序排序
            // return o.num - this.num;
            
            return 0;
            
            // 升序：this - 参数
            // 降序：参数 - this
        }
        
        @Override
        public String toString() {
            return String.valueOf(num);
        }
    }
    
    public static void main(String[] args) {
        // 默认规则排序
        TreeMap treeMap1 = new TreeMap();
        treeMap1.put(3, "A");
        treeMap1.put(3, "A");
        treeMap1.put(1, "C");
        treeMap1.put(2, "B");
        System.out.println(treeMap1); // {1=C, 2=B, 3=A}
        
        // Comparable规则排序
        TreeMap treeMap2 = new TreeMap();
        treeMap2.put(new Inner(3), "A");
        treeMap2.put(new Inner(3), "A");
        treeMap2.put(new Inner(1), "C");
        treeMap2.put(new Inner(2), "B");
        System.out.println(treeMap2); // {3=B}
        
        // Comparator规则排序
        TreeMap<Integer, String> treeMap3 = new TreeMap(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 参数1表示被添加的元素，返回负数时被添加元素放左侧，但返回负数也意味着被添加元素更大，所以是降序排序
                return o2 - o1;
                
                // 升序：参数1 - 参数2
                // 降序：参数2 - 参数1
            }
        });
        treeMap3.put(3, "A");
        treeMap3.put(3, "A");
        treeMap3.put(1, "C");
        treeMap3.put(2, "B");
        System.out.println(treeMap3); // {3=A, 2=B, 1=C}
    }
}
